home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 23 / AMIGAplus Sonderheft 23 (2000)(Falke)(DE)[!].iso / Updates / Librarys / MMULib / Include / mmu / exceptions.h < prev    next >
C/C++ Source or Header  |  1999-10-30  |  11KB  |  289 lines
  1. /*************************************************************************
  2.  ** mmu.library                                                         **
  3.  **                                                                     **
  4.  ** a system library for arbitration and control of the MC68K MMUs      **
  5.  **                                                                     **
  6.  ** © 1998 THOR-Software, Thomas Richter                                **
  7.  ** No commercial use, reassembly, modification without prior, written  **
  8.  ** permission of the authors.                                          **
  9.  ** Including this library in any commercial software REQUIRES a        **
  10.  ** written permission and the payment of a small fee.                  **
  11.  **                                                                     **
  12.  **---------------------------------------------------------------------**
  13.  ** exception related definitions                                       **
  14.  **                                    **
  15.  ** $VER: 40.50 (31.10.99)                        **
  16.  *************************************************************************/
  17.  
  18. #ifndef MMU_EXCEPTIONS_H
  19. #define MMU_EXCEPTIONS_H
  20.  
  21. #ifndef EXEC_TYPES_H
  22. #include <exec/types.h>
  23. #endif
  24.  
  25. #ifndef EXEC_PORTS_H
  26. #include <exec/ports.h>
  27. #endif
  28.  
  29. #ifndef EXEC_INTERRUPTS_H
  30. #include <exec/interrupts.h>
  31. #endif
  32.  
  33.  
  34. /* The exception data structure. This structure is passed in register a0
  35.    for exception hooks and is the one and only information source about
  36.    the exception. This structure will be deleted as soon as the exception
  37.    terminates, hence make a copy for private use if you need to pass it
  38.    over to someone else.
  39.  */
  40.  
  41. struct ExceptionData {
  42.         struct  Task            *exd_Task;
  43. /* The task that caused the exception. Meaningless if this is the exception
  44.    handler of the (a) supervisor context. */
  45.  
  46.         struct MMUContext       *exd_Context;
  47. /* The context this exception is part of. */
  48.  
  49.         ULONG                   *exd_Descriptor;
  50. /* The true physical hardware descriptor as seen by the MMU. In case of
  51.    an indirect descriptor, this points to the pointer, not to (your) page
  52.    descriptor itself. */
  53.  
  54.         ULONG                   *exd_NextDescriptor;
  55. /* In case of a misaligned access, i.e. an access that passes a page
  56.    boundary, the descriptor of the second page involved in the access.
  57.    Otherwise identical to exd_Descriptor */
  58.  
  59.         APTR                     exd_FaultAddress;
  60. /* The address that failed. */
  61.  
  62.         APTR                     exd_NextFaultAddress;
  63. /* This is the final end address, inclusively, of a failed access.
  64.    Note that this might well be less than "exd_FaultAddress", e.g. if the 
  65.    faulty instruction is a movem.l regs,-(ax).
  66.  
  67.    ABS(exd_FaultAdress-exd_NextFaultAddress)+1 is the size of the access
  68.    that failed. Usually 1, 2 and 4 for byte, word and longword accesses, but
  69.    other sizes are possible as well. In case you're writing a swapper daemon,
  70.    make sure you make all addresses within this range valid.
  71. */
  72.  
  73.         ULONG                    exd_UserData;
  74. /* User data for the first page in the failed access if available. This is
  75.    the block Id for swapped out pages. */
  76.  
  77.         ULONG                    exd_NextUserData;
  78. /* User data for the second page in a misaligned access. Identical to 
  79.    exd_UserData otherwise. */
  80.  
  81.         ULONG                    exd_Data;
  82. /* CPU output pipeline, right justified, if available, i.e. if the page(s)
  83.    is (are) marked as MAPP_REPAIRABLE. 
  84.    Can be modified for your code, provided you set the EXDF_READBACK flag
  85.    and the page is repairable. In this case, this data will be loaded back
  86.    to the input pipeline of the CPU. */
  87.  
  88.         APTR                     exd_ReturnPC;
  89. /* The approximate PC of the faulted instruction. Note that the real PC
  90.    might differ due to instruction prefetch. The program is guaranteed to
  91.    continue at the "right" PC, however.
  92.    In case you set the EXDF_CALL flag, this is the pointer to a routine that
  93.    will be called by the library in user mode, e.g. for posting a message
  94.    to the swapper daemon. */
  95.  
  96.         ULONG                    exd_Flags;
  97. /* A flags field, see below for the definitions. */
  98.  
  99.         UBYTE                    exd_internal;
  100. /* Do not read or write this byte. */
  101.  
  102.         ULONG                    exd_Properties;
  103. /* Properties of the accessed memory */
  104.  
  105.         ULONG                    exd_NextProperties;
  106. /*Properties of the next descriptor, if misaligned */
  107.  
  108.         UBYTE                    exd_FunctionCode;
  109. /* The function code mask of the access. */
  110.  
  111.         BYTE                     exd_Level;
  112. /* The level of the *exd_Descriptor responsible for the fault. "0" is the
  113.    level A, "1" is level B and so on. Note that this is different from how
  114.    the 680x0 MMUs count. */
  115.  
  116.         BYTE                     exd_NextLevel;
  117. /* The level of the *exd_NextDescriptor in case of a misalgined access.
  118.    Identical to exd_Level otherwise. */
  119.  
  120.         ULONG                    exd_DataRegs[8];
  121. /* A copy of the data registers of the faulty program. For higher magic,
  122.    you *might* be able to modify these. */
  123.  
  124.         ULONG                    exd_AddrRegs[7];
  125. /* A copy of the address registers, a0 to a6. a7 is below. */
  126.  
  127.         UWORD                   *exd_SSP;
  128. /* The supervisor stack pointer, points to the exception stack frame.
  129.    DO NOT touch this stack frame, this is the buisiness of the library. */
  130.  
  131.         UWORD                   *exd_USP;
  132. /* The user stack pointer. */
  133.  
  134.         struct ExecBase         *exd_SysBase;
  135. /* A cached copy of the exec.library base address. DO NOT access AbsExecBase
  136.    within an exception handler, this will be fatal. Use either a private
  137.    copy or this field. */
  138.  
  139.         struct MMUBase          *exd_MMUBase;
  140. /* The base of the mmu.library. */
  141. };
  142.  
  143. /* The flags set in exd_Flags, above. Note that there are more flags than
  144.    documented here, but DO NOT touch or interpret these. */
  145.  
  146. /* input flags    (set by the exception handler)        */
  147.  
  148.  
  149. #define EXDF_WRITE              (1<<0L)
  150. #define EXDB_WRITE              0L
  151. /* A faulty write if set. A read exception if reset.
  152.    A 060 read/modify/write access will invoke the exception handler twice.
  153.    Note that locked transfers (what is called a RMW-access on a 020 or 030) 
  154.    are neither handled by the Amiga hardware nor the mmu.library software. */ 
  155.  
  156. #define EXDF_INSTRUCTION        (1<<1L)
  157. #define EXDB_INSTRUCTION        1L
  158. /* A faulty instruction access. This means specifically that you MAY NOT
  159.    provide read-back data. You've either to stop the task, or swap in a page.
  160.    Note that EXDF_WRITE and EXDF_INSTRUCTION are possible in case a faulty
  161.    program uses a "moves" instruction with the dfc register loaded with an
  162.    instruction function code. Note, too, that the os never tries to do that
  163.    and that this method is not supported by the mmu.library. */
  164.  
  165. #define EXDF_WRITEPROTECTED     (1<<2L)
  166. #define EXDB_WRITEPROTECTED     2L
  167. /* The fault was due to a write to a write protected page. */
  168.  
  169. #define EXDF_WRITEDATAUNKNOWN   (1<<3L)
  170. #define EXDB_WRITEDATAUNKNOWN   3L
  171. /* The mmu library could not get hold of the data actually written out,
  172.    exd_Data is invalid. Set pages to MAPP_REPAIRABLE to get write data. */
  173.  
  174. #define EXDF_SUPERVISOR         (1<<6L)
  175. #define EXDB_SUPERVISOR         6L
  176. /* The fault was due to access of a supervisor only page. */
  177.  
  178. #define EXDF_MISALIGNED         (1<<8L)
  179. #define EXDB_MISALIGNED         8L
  180. /* The access spawned more than one page in memory. */
  181.  
  182.  
  183. /* The following flags are output flags. You may set them in your code and
  184.    they are respected by the library. */
  185.  
  186. #define EXDF_READBACK           (1<<16L)
  187. #define EXDB_READBACK           16L
  188. /* Fill the input pipeline of the CPU with the data in exd_Data, right
  189.    justified. */
  190.  
  191. #define EXDF_WRITECOMPLETE      (1<<16L)        /* yes, the same number */
  192. #define EXDB_WRITECOMPLETE      16L
  193. /* The exception handler was able to perform the writeback of exd_Data,
  194.    the CPU should ignore the faulty write and continue execution.
  195.    If this bit is not set, the access is retried. */
  196.  
  197. #define EXDF_CALL               (1<<17L)
  198. #define EXDB_CALL               17L
  199. /* Call a routine in user mode, t